

import { createStore } from "vuex";

import demo from "./modules/demo";
import user from "./modules/user";

// 根store  
let store = createStore({
    state() {
        return {
            a: 1,
            b: 2,
            // info:{
            //     name:"张三",
            //     age:18,
            // }
        }
    },
    getters: {
        doubleA: function (state) {
            return state.a * 2;
        },
        doubleB: function (state) {
            return state.b * 2;
        },
        doubleAB: function (state, getters) {
            // return state.a * 2 + state.b * 2;
            return getters.doubleA + getters.doubleB;
        }
    },
    mutations: { // 同步方法
        addA: function (state) {
            state.a++;
        },
        addA_N: function (state, payload) {
            console.log("payload", payload);
            state.a += payload;
        },
        addB: function (state) {
            state.b++;
        }
    },
    actions: {  // 异步方法
        // 没有配合Promise
        /* addA_Async:function(context){
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context",context);  // {state,getters,commit,dispatch}
            setTimeout(()=>{
                context.commit("addA");
            },2000)
        },
        addAN_Async:function(context,payload){
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context",context);  // {state,getters,commit,dispatch}
            setTimeout(()=>{
                context.commit("addA_N",payload);
            },2000)
        },
        addB_Async:function(context){
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context",context);  // {state,getters,commit,dispatch}
            setTimeout(()=>{
                context.commit("addB");
            },2000)
        }, */

        // Promise版
        addA_Async: function (context) {
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context", context);  // {state,getters,commit,dispatch}

            // 默认返回pending状态的Promise实例  => 2s会变为fulfilled状态
            return new Promise(function (resolve) {
                setTimeout(() => {
                    context.commit("addA");
                    resolve(true)
                }, 2000)
            })
        },
        addAN_Async: function (context, payload) {
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context", context);  // {state,getters,commit,dispatch}

            return new Promise(function (resolve) {
                setTimeout(() => {
                    context.commit("addA_N", payload);
                    resolve(true)
                }, 2000)
            })
        },
        addB_Async: function (context) {
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context", context);  // {state,getters,commit,dispatch}
            return new Promise(function (resolve) {
                setTimeout(() => {
                    context.commit("addB");
                    resolve(true);
                }, 2000)
            })
        },

        // action除了调用mutations中的同步方法,也课题通过dispatch调用其他异步方法
        /* addAB_Async: function (context) {
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context", context);  // {state,getters,commit,dispatch}
            // action除了调用mutations中的同步方法,也课题通过dispatch调用其他异步方法

            return new Promise(function (resolve,reject) {
                context.dispatch("addA_Async").then(() => {
                    return context.dispatch("addB_Async")
                }).then(() => {
                    resolve(true);
                }).catch(err=>{
                    reject(err);
                })
            })
        } */
        
        // async await改写异步
        addAB_Async:async function (context) {
            // context   和store实例具有相同方法和属性的 context 对象 (深复制,只复制一层)
            console.log("context", context);  // {state,getters,commit,dispatch}
            // action除了调用mutations中的同步方法,也课题通过dispatch调用其他异步方法

            try{
                await  context.dispatch("addA_Async")
                await  context.dispatch("addB_Async");
                return  true;
            }catch(err){
                // throw 11111
                return Promise.reject(err);
            }
        }

    },
    modules:{
        // 键名 => 模块名
        // 键值 => 模块的配置对象
        demo:demo,
        user,
    }
})


export default store;